import Axios from "axios";
import type { AxiosInstance, AxiosRequestConfig } from "axios";

import type {IRequestParams,IResponseData,TContentType, } from "../types/axios.t";

import { useCounterStore } from '@/stores/counter'
const tokenStore =useCounterStore()
/**
 * 请求服务
 */
export default class HttpService {
  // 请求
  private http!: AxiosInstance;
  // 退出登录
  // private isLogOut = false;

  constructor(url: string) {
    this.http = Axios.create({
      baseURL: url,
      timeout: 60000,
    });
    this.addAnInterceptor();
  }

  // private async fetchData(url: any){
  //   console.log(url);

  //   try {
  //   const response: any = await Axios.get(url);
  //   console.log('响应数据:',response);
  //   }catch (error: any){

  //     console.log('错误错误',error);

  //     if(error.response){
  //     //请求已发出，服务器回应了一个状态码，但状态码超出了 2xx 范围
  //       console.error('错误状态码:',error.response.status);

  //       //加业务请求http拦截器
  //       console.error('错误信息:',error.response.data);
  //     } else if(error.request){
  //     //请求已发出，但未收到响应
  //     console.error('请求未收到响应:', error.request);
  //     } else {
  //     // 其他错误
  //     console.error('错误信息:', error.message);
  //     }
  //   }
  // }

  /**
   * 获得http状态提示消息
   * @param err 错误信息
   * @private
   */
  private getHttpStatusMessage(err: any): string {
    if (err && err.response) {
      switch (err.response.status) {
        case 400:
          return "错误请求";
        case 401:
          return "未授权，请重新登录";
        case 403:
          return "拒绝访问";
        case 404:
          return "请求错误,未找到该资源";
        case 405:
          return "请求方法未允许";
        case 408:
          return "请求超时";
        case 500:
          return "服务器端出错";
        case 501:
          return "网络未实现";
        case 502:
          return "网络错误";
        case 503:
          return "服务不可用";
        case 504:
          return "网络超时";
        case 505:
          return "http版本不支持该请求";
        default:
          return `连接错误${err.response.status}`;
      }
    } else {
      return "连接到服务器失败";
    }
  }

  /**
   * 添加拦截器
   * @private
   */
  private addAnInterceptor() {
    try {
      // 请求拦截器
      this.http.interceptors.request.use(
        (config: any) => {
          const token = tokenStore.token;
          if (token) {
            config.headers.Authorization = token;
          }
          return config;
        },
        (err: any) => {
          return err;
        }
      );
      // 请求响应器
      this.http.interceptors.response.use(
        (response: any) => {
          const result = response.data;
          if (response.status === 200) {
            // console.log('请求响应器====200');
            if (response.data.hasOwnProperty("results")) {
              let res =  response.data.results
              return JSON.parse(res)
            } else  {
              if (result.code === 200 || result.code === '200' ) {
                return result;
              } else if (result.code === 403 || result.code === '403') {
                window.location.href = "/login";

              } else {
                // console.log('请求响应器 222222222222');
                // alert(result.message);
              }
            }
            
          } else {
            alert("服务器异常");
          }
          return Promise.reject(result);
        },
        (err) => Promise.reject({ msg: this.getHttpStatusMessage(err) })
      );
    } catch (error) {
      console.log("请求响应器error", error);
    }
  }

  /**
   * 处理数据
   * @param contentType 请求主体类型
   * @param data 数据
   * @private
   */
  private handleTypeData(
    contentType: TContentType | undefined,
    data?: unknown
  ) {
    if (data && contentType === "form-data") {
      return JSON.stringify(data);
    } else if (data && contentType === "form-data-file") {
      const formData = new FormData();
      for (const key in data) {
        const ele = data[key as keyof typeof data];
        formData.append(key, ele);
      }
      return formData;
    }
    return data;
  }

  /**
   * 除了请求头
   * @param requestConfig 请求配置
   * @private
   */
  private handleRequestHeader(
    requestConfig: IRequestParams | undefined
  ): AxiosRequestConfig {
    // 配置
    const config: AxiosRequestConfig = requestConfig?.config || {};
    // 设置请求销毁
    config.cancelToken = new Axios.CancelToken((cancel) => {
      requestConfig?.cancelToken && requestConfig.cancelToken(cancel);
    });
    return config;
  }

  /**
   * get请求方式
   * @param url 请求地址
   * @param config 配置
   */
  get<T = any>(
    url: string,
    config?: IRequestParams
  ): Promise<IResponseData<T>> {
    return this.http.get(url, this.handleRequestHeader(config));
  }

  /**
   * delete请求方式
   * @param url 请求地址
   * @param config 配置
   */
  delete<T = any>(
    url: string,
    config?: IRequestParams
  ): Promise<IResponseData<T>> {
    return this.http.delete(url, this.handleRequestHeader(config));
  }

  /**
   * post请求方式
   * @param url 请求地址
   * @param data 请求数据
   * @param config 配置
   */
  post<T = any>(
    url: string,
    data?: unknown,
    config?: IRequestParams
  ): Promise<IResponseData<T>> {
    return this.http.post(
      url,
      this.handleTypeData(config?.contentType, data),
      this.handleRequestHeader(config)
    );
  }

  /**
   * put请求方式
   * @param url 请求地址
   * @param data 请求数据
   * @param config 配置
   */
  put<T = any>(
    url: string,
    data?: unknown,
    config?: IRequestParams
  ): Promise<IResponseData<T>> {
    return this.http.put(
      url,
      this.handleTypeData(config?.contentType, data),
      this.handleRequestHeader(config)
    );
  }
}
